package com.example.commonexport.service;

import org.springframework.stereotype.Component;

import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;

@Component
// 导出任务执行器 - 单例模式
public class ExportTaskExecutor {
    private static ExportTaskExecutor instance;
    private final BlockingQueue<Runnable> taskQueue;
    private final ThreadPoolExecutor executor;
    private final AtomicBoolean isProcessing;

    private ExportTaskExecutor() {
        // 创建一个容量无限的任务队列
        taskQueue = new LinkedBlockingQueue<>();
        
        // 创建一个固定大小的线程池，只使用一个工作线程
        executor = new ThreadPoolExecutor(
            1,                // 核心线程数
            1,                // 最大线程数
            0L, TimeUnit.MILLISECONDS,
            taskQueue,
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
        
        // 设置线程工厂，给线程命名便于调试
        executor.setThreadFactory(r -> {
            Thread t = new Thread(r);
            t.setName("ExportTaskThread");
            t.setDaemon(true);
            return t;
        });
        
        isProcessing = new AtomicBoolean(false);
    }

    // 获取单例实例
    public static synchronized ExportTaskExecutor getInstance() {
        if (instance == null) {
            instance = new ExportTaskExecutor();
        }
        return instance;
    }

    // 提交导出任务
    public Future<?> submitExportTask(ExportTask task) {
        return executor.submit(() -> {
            try {
                // 标记为正在处理
                isProcessing.set(true);
                // 执行导出任务
                task.execute();
            } catch (Exception e) {
                System.err.println("导出任务执行失败: " + e.getMessage());
                e.printStackTrace();
            } finally {
                // 标记处理完成
                isProcessing.set(false);
            }
        });
    }


    // 关闭执行器
    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }

    // 获取待处理任务数量
    public int getPendingTaskCount() {
        return taskQueue.size();
    }

    // 检查是否有任务正在处理
    public boolean isProcessing() {
        return isProcessing.get();
    }
}    